home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 September / PCWorld_2008-09_cd.bin / domacnost a kancelar / joomla / Joomla_1.5.4-Stable-Full_Package.exe / libraries / loader.php < prev   
PHP Script  |  2008-07-06  |  4KB  |  188 lines
  1. <?php
  2. /**
  3. * @version $Id: loader.php 10381 2008-06-01 03:35:53Z pasamio $
  4. * @package        Joomla.Framework
  5. * @copyright    Copyright (C) 2005 - 2008 Open Source Matters. All rights reserved.
  6. * @license        GNU/GPL, see LICENSE.php
  7. * Joomla! is free software. This version may have been modified pursuant
  8. * to the GNU General Public License, and as distributed it includes or
  9. * is derivative of works licensed under the GNU General Public License or
  10. * other free or open source software licenses.
  11. * See COPYRIGHT.php for copyright notices and details.
  12. */
  13.  
  14. if(!defined('DS')) {
  15.     define( 'DS', DIRECTORY_SEPARATOR );
  16. }
  17.  
  18. /**
  19.  * @package        Joomla.Framework
  20.  */
  21. class JLoader
  22. {
  23.      /**
  24.      * Loads a class from specified directories.
  25.      *
  26.      * @param string $name    The class name to look for ( dot notation ).
  27.      * @param string $base    Search this directory for the class.
  28.      * @param string $key    String used as a prefix to denote the full path of the file ( dot notation ).
  29.      * @return void
  30.      * @since 1.5
  31.      */
  32.     function import( $filePath, $base = null, $key = 'libraries.' )
  33.     {
  34.         static $paths;
  35.  
  36.         if (!isset($paths)) {
  37.             $paths = array();
  38.         }
  39.  
  40.         $keyPath = $key ? $key . $filePath : $filePath;
  41.  
  42.         if (!isset($paths[$keyPath]))
  43.         {
  44.             if ( ! $base ) {
  45.                 $base =  dirname( __FILE__ );
  46.             }
  47.  
  48.             $parts = explode( '.', $filePath );
  49.  
  50.             $classname = array_pop( $parts );
  51.             switch($classname)
  52.             {
  53.                 case 'helper' :
  54.                     $classname = ucfirst(array_pop( $parts )).ucfirst($classname);
  55.                     break;
  56.  
  57.                 default :
  58.                     $classname = ucfirst($classname);
  59.                     break;
  60.             }
  61.  
  62.             $path  = str_replace( '.', DS, $filePath );
  63.  
  64.             if (strpos($filePath, 'joomla') === 0)
  65.             {
  66.                 /*
  67.                  * If we are loading a joomla class prepend the classname with a
  68.                  * capital J.
  69.                  */
  70.                 $classname    = 'J'.$classname;
  71.                 $classes    = JLoader::register($classname, $base.DS.$path.'.php');
  72.                 $rs            = isset($classes[strtolower($classname)]);
  73.             }
  74.             else
  75.             {
  76.                 /*
  77.                  * If it is not in the joomla namespace then we have no idea if
  78.                  * it uses our pattern for class names/files so just include.
  79.                  */
  80.                 $rs   = include($base.DS.$path.'.php');
  81.             }
  82.  
  83.             $paths[$keyPath] = $rs;
  84.         }
  85.  
  86.         return $paths[$keyPath];
  87.     }
  88.  
  89.     /**
  90.      * Add a class to autoload
  91.      *
  92.      * @param    string $classname    The class name
  93.      * @param    string $file        Full path to the file that holds the class
  94.      * @return    array|boolean          Array of classes
  95.      * @since     1.5
  96.      */
  97.     function & register ($class = null, $file = null)
  98.     {
  99.         static $classes;
  100.  
  101.         if(!isset($classes)) {
  102.             $classes    = array();
  103.         }
  104.  
  105.         if($class && is_file($file))
  106.         {
  107.             // Force to lower case.
  108.             $class = strtolower($class);
  109.             $classes[$class] = $file;
  110.  
  111.             // In php4 we load the class immediately.
  112.             if((version_compare( phpversion(), '5.0' ) < 0)) {
  113.                 JLoader::load($class);
  114.             }
  115.  
  116.         }
  117.  
  118.         return $classes;
  119.     }
  120.  
  121.  
  122.     /**
  123.      * Load the file for a class
  124.      *
  125.      * @access  public
  126.      * @param   string  $class  The class that will be loaded
  127.      * @return  boolean True on success
  128.      * @since   1.5
  129.      */
  130.     function load( $class )
  131.     {
  132.         $class = strtolower($class); //force to lower case
  133.  
  134.         if (class_exists($class)) {
  135.               return;
  136.         }
  137.  
  138.         $classes = JLoader::register();
  139.         if(array_key_exists( strtolower($class), $classes)) {
  140.             include($classes[$class]);
  141.             return true;
  142.         }
  143.         return false;
  144.     }
  145. }
  146.  
  147.  
  148. /**
  149.  * When calling a class that hasn't been defined, __autoload will attempt to
  150.  * include the correct file for that class.
  151.  *
  152.  * This function get's called by PHP. Never call this function yourself.
  153.  *
  154.  * @param     string     $class
  155.  * @access     public
  156.  * @return  boolean
  157.  * @since   1.5
  158.  */
  159. function __autoload($class)
  160. {
  161.     if(JLoader::load($class)) {
  162.         return true;
  163.     }
  164.     return false;
  165. }
  166.  
  167. /**
  168.  * Global application exit.
  169.  *
  170.  * This function provides a single exit point for the framework.
  171.  *
  172.  * @param mixed Exit code or string. Defaults to zero.
  173.  */
  174. function jexit($message = 0) {
  175.     exit($message);
  176. }
  177.  
  178. /**
  179.  * Intelligent file importer
  180.  *
  181.  * @access public
  182.  * @param string $path A dot syntax path
  183.  * @since 1.5
  184.  */
  185. function jimport( $path ) {
  186.     return JLoader::import($path);
  187. }
  188.